﻿/* 
* Copyright (c) 2010, The University of Texas at Austin
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, 
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, 
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, 
* this list of conditions and the following disclaimer in the documentation and/or other materials 
* provided with the distribution.
*
* Neither the name of The University of Texas at Austin nor the names of its contributors may be 
* used to endorse or promote products derived from this software without specific prior written 
* permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR 
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Windows;
using System.Windows.Media;
using Bio.Views.Structure.Editor.Internal.Data;
using Bio.Views.Structure.Editor.Internal.Options;
using Bio.Views.Structure.Editor.Internal.Rendering;
using JulMar.Windows.Mvvm;

namespace Bio.Views.Structure.Editor.ViewModels
{
    public class NucleotideVisualRenderingOptionsViewModel : SimpleViewModel
    {
        public string Label
        {
            get { return Data.Label; }
        }

        public FontFamily TextFont
        {
            get { return Data.Options.NucleotideFontFamily; }
            set
            {
                Data.Options.NucleotideFontFamily = value;
                OnPropertyChanged("TextFont");
            }
        }

        public List<FontFamily> ValidTextFonts
        {
            get { return _validTextFonts; }
            private set
            {
                _validTextFonts = value;
                OnPropertyChanged("ValidTextFonts");
            }
        }

        public FontStyle TextStyle
        {
            get { return Data.Options.NucleotideFontStyle; }
            set
            {
                Data.Options.NucleotideFontStyle = value;
                OnPropertyChanged("TextStyle");
            }
        }

        public List<FontStyle> ValidTextStyles
        {
            get { return _validTextStyles; }
            private set
            {
                _validTextStyles = value;
                OnPropertyChanged("ValidTextStyles");
            }
        }

        public FontWeight TextWeight
        {
            get { return Data.Options.NucleotideFontWeight; }
            set
            {
                Data.Options.NucleotideFontWeight = value;
                OnPropertyChanged("TextWeight");
            }
        }

        public List<FontWeight> ValidTextWeights
        {
            get { return _validTextWeights; }
            private set
            {
                _validTextWeights = value;
                OnPropertyChanged("ValidTextWeights");
            }
        }

        public double TextSize
        {
            get { return Data.Options.NucleotideFontSize; }
            set
            {
                Data.Options.NucleotideFontSize = value;
                OnPropertyChanged("TextSize");
            }
        }

        public List<double> ValidTextSizes
        {
            get { return _validFontSizes; }
            private set
            {
                _validFontSizes = value;
                OnPropertyChanged("ValidTextSizes");
            }
        }

        public List<NamedColor> ValidColors
        {
            get { return _validColors; }
            private set
            {
                _validColors = value;
                OnPropertyChanged("ValidColors");
            }
        }

        public Brush TextFill
        {
            get { return Data.Options.NucleotideFill; }
            set
            {
                Data.Options.NucleotideFill = value;
                OnPropertyChanged("TextFill");
            }
        }

        public double CircleDiameter
        {
            get { return Data.Options.NucleotideCircleDiameter; }
            set
            {
                if (value >= 0.0)
                {
                    Data.Options.NucleotideCircleDiameter = value;
                    OnPropertyChanged("CircleDiameter");
                }
            }
        }

        public double CircleEdgeThickness
        {
            get { return Data.Options.NucleotideCircleEdgeThickness; }
            set
            {
                if (value >= 0.0)
                {
                    Data.Options.NucleotideCircleEdgeThickness = value;
                    OnPropertyChanged("CircleEdgeThickness");
                }
            }
        }

        public bool CircleIsFilled
        {
            get { return Data.Options.NucleotideCircleIsFilled; }
            set
            {
                Data.Options.NucleotideCircleIsFilled = value;
                OnPropertyChanged("CircleIsFilled");
            }
        }

        public Brush CircleStroke
        {
            get { return Data.Options.NucleotideCircleStroke; }
            set
            {
                Data.Options.NucleotideCircleStroke = value;
                OnPropertyChanged("CircleStroke");
            }
        }

        public Brush CircleFill
        {
            get { return Data.Options.NucleotideCircleFill; }
            set
            {
                Data.Options.NucleotideCircleFill = value;
                OnPropertyChanged("CircleFill");
            }
        }

        public List<string> ValidRenderingModes
        {
            get { return _validRenderingModes; }
            private set
            {
                _validRenderingModes = value;
                OnPropertyChanged("ValidRenderingModes");
            }
        }

        public string RenderingMode
        {
            get { return Data.Options.NucleotideRenderingStyle.ToString(); }
            set
            {
                NucleotideRenderingMode mode;
                if (Enum.TryParse(value, true, out mode))
                {
                    Data.Options.NucleotideRenderingStyle = mode;
                    OnPropertyChanged("RenderingMode");
                }
            }
        }

        public NucleotideVisualRenderingOptionsViewModel(NucleotideVisualRenderingOptionsData data)
        {
            Data = data;
            ValidTextFonts = new List<FontFamily>() 
            { new FontFamily("Arial"), 
              new FontFamily("Courier"), 
              new FontFamily("Courier New"), 
              new FontFamily("Times"), 
              new FontFamily("TimesNewRoman"), 
              new FontFamily("Symbol") };

            ValidTextWeights = new List<FontWeight>() { FontWeights.Regular, FontWeights.Bold };
            ValidTextStyles = new List<FontStyle>() { FontStyles.Normal, FontStyles.Italic, FontStyles.Oblique };
            ValidTextSizes = new List<double>() { 6, 8, 10, 12, 14, 16, 18, 20, 24 };
            List<NamedColor> builtIn = new List<NamedColor>();
            PropertyInfo[] colorProperties = typeof(Colors).GetProperties();
            foreach (var propertyinfo in colorProperties)
            {
                Color color = (Color)ColorConverter.ConvertFromString(propertyinfo.Name);
                NamedColor ntColor = new NamedColor() { Color = color, Label = propertyinfo.Name };
                builtIn.Add(ntColor);   
            }
            ValidColors = builtIn;
            List<string> renderingModes = new List<string>();
            foreach (var val in Enum.GetNames(typeof(NucleotideRenderingMode)))
            {
                if(!val.Equals(NucleotideRenderingMode.Rectangle.ToString())) //Filtering out rectangle for now since its unsupported in the visual layer.
                    renderingModes.Add(val);
            }
            ValidRenderingModes = renderingModes;
        }

        private NucleotideVisualRenderingOptionsData _data;
        private NucleotideVisualRenderingOptionsData Data 
        {
            get { return _data; }
            set
            {
                _data = value;
                OnPropertyChanged("TextFont", "TextStyle", "TextWeight", "TextFill", "CircleDiameter", "CircleEdgeThickness", "CircleIsFilled", "CircleStroke", "CircleFill", "RenderingMode");
            }
        }
        private List<FontFamily> _validTextFonts;
        private List<FontStyle> _validTextStyles;
        private List<FontWeight> _validTextWeights;
        private List<double> _validFontSizes;
        private List<NamedColor> _validColors;
        private List<string> _validRenderingModes;
    }
}
